home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 4: GNU Archives / Linux Cubed Series 4 - GNU Archives.iso / gnu / gnu-objc.0 / gnu-objc / krab-runtime < prev    next >
Encoding:
Internet Message Format  |  1993-02-28  |  38.7 KB
  1. Return-Path: <krab@iesd.auc.dk>
  2. Date: Wed, 10 Feb 1993 03:17:38 +0100
  3. From: Kresten Krab Thorup <krab@iesd.auc.dk>
  4. To: rms@gnu.ai.mit.edu, gnu-objc-submissions@prep.ai.mit.edu
  5. Subject: Gnu objc runtime [comments and bug reports]
  6. Cc: krab@iesd.auc.dk
  7.  
  8. Hi <whoever may recieve this letter> !
  9.  
  10. I have found a number of bugs in the current runtime -- the following
  11. list describes the patch included below.
  12.  
  13.    * class Object *   
  14.  
  15.      # Added methods for alloc/init scheme.  
  16.  
  17.      # Changed isEqual so that bcmp on instances is done, instead of
  18.      comparing the object pointers only.  I dont know if this is the
  19.      right semathics, but it surely is more natural.  
  20.  
  21.      # Changed hash function to be more portable, and so that it only
  22.      uses `self' if it cannot avoid it.  It is a desired property,
  23.      that two isEqual instances gives the same hash value.  
  24.  
  25.      # Added perform with two objects.  
  26.  
  27.      # Fixed subclassResponsibility, notImplemented and
  28.      doesNotRecognize, which didnt sel_getName the selector before it
  29.      was printet!    
  30.  
  31.      # Fixed readFrom so that it does better checking, and gives more
  32.      meaningful error messages.  It now also checks the version. 
  33.  
  34.    * mutex.h * 
  35.  
  36.      # Added support for my own (soon-to-be-released) co routines.
  37.      These are done in ObjC, so it's quite nice...   
  38.   
  39.    * objc-proto.h *  
  40.    
  41.       # Fixed it so that is include'able from objective C code.  It
  42.       wasnt - HOST_BITS_PER_LONG was missing. 
  43.  
  44.    * objc.h *
  45.  
  46.       #  Fixed so that it is include'able from objc code. varargs.h
  47.       was missing. 
  48.  
  49.    * record.h *
  50.  
  51.       #  Fixed two BAD assertions, checking record_entries instead of
  52.       record_capacity. 
  53.  
  54.    * core.c *
  55.  
  56.       # Changed list of included files, so that it may now be compiled
  57.       with an objc compiler.   
  58.  
  59.       # Changed msgSend scheme:  objc_msgSend is now a pointer two a
  60.       function. core.c defines two messengers, one equal to the
  61.       present doing extensively initialization checking, and one
  62.       bare-bone with no such checks (more on initialization at next item)
  63.       This also allows the programmer to do his own messengers -- fun!
  64.  
  65.       # execClass is heavily changed. 
  66.  
  67.         The first time it is called, it installs the heavy version
  68.     of objc_msgSend, so that initialization is handles correctly.
  69.     This one is called __initializing_objc_msgSend -- there is
  70.     also a msgSendSuper with a name like that...
  71.  
  72.     Fixed terrible bug in resolving of class relationship.  In
  73.     line 351, it doesnt check if a class has already been
  74.     resolved, so it will try numerous times... Making only more
  75.     garbage each time.   
  76.  
  77.     Added debugging `printf' displaying cause of failure if
  78.     execClass cannot resolve all classes. 
  79.  
  80.     When all classes have their class-relationships resolved,
  81.     (i.e. the last time it is called), It calls +initialize for
  82.     all classes.  (still using the heavy messenger)  it is not
  83.     called if it has already been done if a +initialize method has
  84.     invoked it indirectly by doing message passing to other
  85.     objects.
  86.  
  87.     Finally, the fast messenger is installed -- we know that all
  88.     classes have been initialized.  This one is called
  89.     __builtin_objc_msgSend -- is such names only for compilers? 
  90.  
  91.       # Changed initialize_class to get a Class_t instead of a class
  92.       names, all invocations said someclass->name, so we can save a
  93.       little in lookup here.   Also the class is marked as initialized
  94.       BEFORE the +initialize method is invoked -- this is needed, if
  95.       that method somehow calls a method in the class it comes from.
  96.  
  97.       # Changed all malloc, calloc etc to either __objc_xmalloc and
  98.       friends, or simply xmalloc and friends.  This gives more control
  99.       of how allocation is done.  Why does malloc come in those two
  100.       flavours anyway?
  101.  
  102.     * hash.c *  
  103.  
  104.       # Changed calloc, malloc into xcalloc, xmalloc -- we _want_
  105.       fatal errors if such things fail...
  106.  
  107.       
  108. This actually makes it possible to compile and run objective C
  109. programs using GNU C.  
  110.  
  111. I am working on a collection library -- it is mostly finished, I'm
  112. writing some documentation currently.   It's designed purely after
  113. Smalltalk, of course with appropriate performance onsiderations.  I
  114. hope to be able to let you test it out for me in the near future.
  115.  
  116. Any comments on the above are stongly appreciated.
  117.  
  118. /Kresten
  119.  
  120. ======================================================================
  121. diff -c ../orig/Object.h objc/Object.h
  122. *** ../orig/Object.h    Tue Feb  9 20:20:19 1993
  123. --- objc/Object.h    Mon Feb  8 21:07:19 1993
  124. ***************
  125. *** 49,54 ****
  126. --- 49,57 ----
  127.   /* Creating, copying, and freeing instances */
  128.   
  129.   + new;
  130. + + alloc;
  131. + - init;
  132. + 
  133.   + free;
  134.   - free;
  135.   - copy;
  136. ***************
  137. *** 62,67 ****
  138. --- 65,71 ----
  139.   - ( Class_t )class;
  140.   - ( Class_t )superClass;
  141.   - ( const char* )name;
  142. + + ( BOOL )isEqual:aClass;
  143.   
  144.   /* Identifying and comparing instances */
  145.   
  146. ***************
  147. *** 85,90 ****
  148. --- 89,95 ----
  149.   
  150.   - perform:( SEL )aSel;
  151.   - perform:( SEL )aSel with:aObject;
  152. + - perform:( SEL )aSel with:firstObject with:secondObject;
  153.   
  154.   /* Posing */
  155.   
  156. diff -c ../orig/mutex.h objc/mutex.h
  157. *** ../orig/mutex.h    Tue Feb  9 20:20:20 1993
  158. --- objc/mutex.h    Tue Feb  9 00:32:13 1993
  159. ***************
  160. *** 36,46 ****
  161.   #define MUTEX_UNLOCK(mutex) mutex_unlock (mutex)
  162.   #define MUTEX_ISLOCK(mutex)     mutex->lock /* Gak */
  163.   
  164. ! #elif defined (OSF)
  165.   
  166. ! #elif defined (mach)
  167.   
  168. ! #elif defined (sun)
  169.   /*
  170.    * Sun lwp uses monitors.
  171.    *
  172. --- 36,46 ----
  173.   #define MUTEX_UNLOCK(mutex) mutex_unlock (mutex)
  174.   #define MUTEX_ISLOCK(mutex)     mutex->lock /* Gak */
  175.   
  176. ! #elif defined (OSF) && !defined (COROUTINES)
  177.   
  178. ! #elif defined (mach) && !defined (COROUTINES)
  179.   
  180. ! #elif defined (sun) && !defined (COROUTINES)
  181.   /*
  182.    * Sun lwp uses monitors.
  183.    *
  184. ***************
  185. *** 86,91 ****
  186. --- 86,102 ----
  187.    * A environment where threads are implemented as a
  188.    *  set of coroutines.
  189.    */
  190. + 
  191. + #include <util/Semaphore.h>   /* this is my co-routine impl (KKT) */
  192. + 
  193. + #define MUTEX Semaphore*
  194. + #define MUTEX_ALLOC(mutex)   { *mutex = [Semaphore alloc]; }
  195. + #define MUTEX_INIT(mutex)    [mutex init]
  196. + #define MUTEX_FREE(mutex)    [mutex free]
  197. + #define MUTEX_LOCK(mutex)    [mutex wait]
  198. + #define MUTEX_ISLOCK(mutex)  [mutex wouldBlock]
  199. + #define MUTEX_UNLOCK(mutex)  [mutex signal]
  200. + 
  201.   
  202.   #endif
  203.   #endif
  204. diff -c ../orig/objc-proto.h objc/objc-proto.h
  205. *** ../orig/objc-proto.h    Tue Feb  9 20:20:20 1993
  206. --- objc/objc-proto.h    Mon Feb  8 11:37:34 1993
  207. ***************
  208. *** 27,32 ****
  209. --- 27,37 ----
  210.   #ifndef __objc_proto_INCLUDE_GNU
  211.   #define __objc_proto_INCLUDE_GNU
  212.   
  213. + #ifndef HOST_BITS_PER_LONG         /* missing? */
  214. + #include <sys/limits.h>
  215. + #define HOST_BITS_PER_LONG (sizeof(long)*CHAR_BIT)
  216. + #endif
  217. + 
  218.   /* This used to be #ifndef __OBJC__, but it turns out that
  219.      object.m needs these declarations.  I don't understand why one
  220.      might want to avoid them in object.m.  */
  221. diff -c ../orig/objc.h objc/objc.h
  222. *** ../orig/objc.h    Tue Feb  9 20:20:20 1993
  223. --- objc/objc.h    Mon Feb  8 11:37:34 1993
  224. ***************
  225. *** 27,32 ****
  226. --- 27,34 ----
  227.   #ifndef __objc_INCLUDE_GNU
  228.   #define __objc_INCLUDE_GNU
  229.   
  230. + #include <varargs.h>
  231. + 
  232.   /* If someone is using a c++ compiler then adjust the types in the
  233.      file back to C.  */
  234.   #ifdef __cplusplus
  235. diff -c ../orig/record.h objc/record.h
  236. *** ../orig/record.h    Tue Feb  9 20:20:21 1993
  237. --- objc/record.h    Tue Feb  9 03:23:10 1993
  238. ***************
  239. *** 92,98 ****
  240.   record_store_at (unsigned int i, void *value, struct record *record)
  241.   {
  242.     assert (i);
  243. !   assert (i <= record_entries (record));
  244.   
  245.     record->records[i] = value;
  246.   }
  247. --- 92,98 ----
  248.   record_store_at (unsigned int i, void *value, struct record *record)
  249.   {
  250.     assert (i);
  251. !   assert (i <= record_capacity (record));
  252.   
  253.     record->records[i] = value;
  254.   }
  255. ***************
  256. *** 121,127 ****
  257.   record_get (unsigned int i, struct record *record)
  258.   {
  259.     assert (i);
  260. !   assert (i <= record_entries (record));
  261.     return record->records[i];
  262.   }
  263.   
  264. --- 121,127 ----
  265.   record_get (unsigned int i, struct record *record)
  266.   {
  267.     assert (i);
  268. !   assert (i <= record_capacity (record));
  269.     return record->records[i];
  270.   }
  271.   
  272. diff -c ../orig/core.c objc/core.c
  273. *** ../orig/core.c    Tue Feb  9 20:20:19 1993
  274. --- objc/core.c    Tue Feb  9 06:27:16 1993
  275. ***************
  276. *** 23,34 ****
  277.      This exception does not however invalidate any other reasons why
  278.      the executable file might be covered by the GNU General Public License.  */
  279.   
  280. - #include "tconfig.h"
  281.   #include "assert.h"
  282.   #include <ctype.h>
  283. ! #include "gstdarg.h"
  284.   #include <stdio.h>
  285. ! #include "gstddef.h"
  286.   
  287.   #include "hash.h"
  288.   #include "objc.h"
  289. --- 23,33 ----
  290.      This exception does not however invalidate any other reasons why
  291.      the executable file might be covered by the GNU General Public License.  */
  292.   
  293.   #include "assert.h"
  294.   #include <ctype.h>
  295. ! #include "stdarg.h"
  296.   #include <stdio.h>
  297. ! #include "stddef.h"
  298.   
  299.   #include "hash.h"
  300.   #include "objc.h"
  301. ***************
  302. *** 56,62 ****
  303.   static SEL    record_selector (const char*);
  304.   static void   record_methods_from_class (Class_t);
  305.   static void   record_methods_from_list (MethodList_t);
  306. ! static void   initialize_class (const char*);
  307.   /*
  308.    * This is a hash table of Class_t structures. 
  309.    *
  310. --- 55,75 ----
  311.   static SEL    record_selector (const char*);
  312.   static void   record_methods_from_class (Class_t);
  313.   static void   record_methods_from_list (MethodList_t);
  314. ! static void   initialize_class (Class_t);
  315. ! 
  316. ! /* objc_msgSend comes in 3 variants... */
  317. ! IMP objc_msgSend(id receiver, SEL selector);
  318. ! IMP __builtin_objc_msgSend(id receiver, SEL selector);
  319. ! IMP __initializing_objc_msgSend(id receiver, SEL selector);
  320. ! IMP (*__objc_msgSend)(id receiver, SEL selector) = __initializing_objc_msgSend;
  321. ! 
  322. ! /* as does objc_msgSendSuper */
  323. ! IMP objc_msgSendSuper(Super_t receiver, SEL selector);
  324. ! IMP __builtin_objc_msgSendSuper(Super_t receiver, SEL selector);
  325. ! IMP __initializing_objc_msgSendSuper(Super_t receiver, SEL selector);
  326. ! IMP (*__objc_msgSendSuper)(Super_t receiver, SEL selector) =
  327. !        __initializing_objc_msgSendSuper;
  328. ! 
  329.   /*
  330.    * This is a hash table of Class_t structures. 
  331.    *
  332. ***************
  333. *** 84,89 ****
  334. --- 97,105 ----
  335.   /* This mutex provides a course lock for method dispatch.  */
  336.   MUTEX    runtimeMutex;
  337.   
  338. + /* This mutex provides lock for malloc and friends */
  339. + MUTEX   mallocMutex;
  340. + 
  341.   /*
  342.    * This hash table is used by the initialization routines.  When the
  343.    * constructor function (__objc_execClass) is called it is passed a pointer
  344. ***************
  345. *** 185,203 ****
  346.     exit (1);
  347.   }
  348.   
  349. ! static void *
  350.   xmalloc (unsigned int size)
  351.   {
  352. !   void *ptr = (void *) malloc (size);
  353.     if (ptr == 0)
  354.       fatal ("virtual memory exceeded");
  355.     return ptr;
  356.   }
  357.   
  358. ! static void *
  359.   xcalloc (unsigned int size, unsigned int units)
  360.   {
  361. !   void *ptr = (void *) calloc (size, units);
  362.     if (ptr == 0)
  363.       fatal ("virtual memory exceeded");
  364.     return ptr;
  365. --- 201,230 ----
  366.     exit (1);
  367.   }
  368.   
  369. !  void *
  370.   xmalloc (unsigned int size)
  371.   {
  372. !   void *ptr;
  373. !   ptr = (void *) malloc (size);
  374. !   if (ptr == 0)
  375. !     fatal ("virtual memory exceeded");
  376. !   return ptr;
  377. ! }
  378. ! 
  379. !  void *
  380. ! xrealloc (void* ptr, unsigned int size)
  381. ! {
  382. !   ptr = (void *) realloc (ptr, size);
  383.     if (ptr == 0)
  384.       fatal ("virtual memory exceeded");
  385.     return ptr;
  386.   }
  387.   
  388. !  void *
  389.   xcalloc (unsigned int size, unsigned int units)
  390.   {
  391. !   void *ptr;
  392. !   ptr = (void *) calloc (size, units);
  393.     if (ptr == 0)
  394.       fatal ("virtual memory exceeded");
  395.     return ptr;
  396. ***************
  397. *** 206,212 ****
  398.   void *
  399.   __objc_xmalloc (unsigned int size)
  400.   {
  401. !   void *ptr = (void *) malloc (size);
  402.     if (ptr == 0)
  403.       fatal ("virtual memory exceeded");
  404.     return ptr;
  405. --- 233,240 ----
  406.   void *
  407.   __objc_xmalloc (unsigned int size)
  408.   {
  409. !   void *ptr;
  410. !   ptr = (void *) malloc (size);
  411.     if (ptr == 0)
  412.       fatal ("virtual memory exceeded");
  413.     return ptr;
  414. ***************
  415. *** 215,221 ****
  416.   void *
  417.   __objc_xrealloc (void *optr, unsigned int size)
  418.   {
  419. !   void *ptr = (void *) realloc (optr, size);
  420.     if (ptr == 0)
  421.       fatal ("virtual memory exceeded");
  422.     return ptr;
  423. --- 243,250 ----
  424.   void *
  425.   __objc_xrealloc (void *optr, unsigned int size)
  426.   {
  427. !   void *ptr;
  428. !   ptr = (void *) realloc (optr, size);
  429.     if (ptr == 0)
  430.       fatal ("virtual memory exceeded");
  431.     return ptr;
  432. ***************
  433. *** 224,230 ****
  434.   void *
  435.   __objc_xcalloc (unsigned int size, unsigned int units)
  436.   {
  437. !   void *ptr = (void *) calloc (size, units);
  438.     if (ptr == 0)
  439.       fatal ("virtual memory exceeded");
  440.     return ptr;
  441. --- 253,260 ----
  442.   void *
  443.   __objc_xcalloc (unsigned int size, unsigned int units)
  444.   {
  445. !   void *ptr;
  446. !   ptr = (void *) calloc (size, units);
  447.     if (ptr == 0)
  448.       fatal ("virtual memory exceeded");
  449.     return ptr;
  450. ***************
  451. *** 247,254 ****
  452.    * The purpose of this function is to gather the module pointers so that they
  453.    * may be processed by the initialization clean up routine. 
  454.    */
  455. ! void 
  456. ! __objc_execClass (Module_t module)
  457.   {
  458.     /* Has we processed any constructors previously? 
  459.        Flag used to indicate that some global data structures
  460. --- 277,284 ----
  461.    * The purpose of this function is to gather the module pointers so that they
  462.    * may be processed by the initialization clean up routine. 
  463.    */
  464. ! void            /* it is declared void* in objc-actions.c */
  465. ! __objc_execClass (void* theModule)
  466.   {
  467.     /* Has we processed any constructors previously? 
  468.        Flag used to indicate that some global data structures
  469. ***************
  470. *** 255,260 ****
  471. --- 285,291 ----
  472.        need to be built.  */
  473.     static BOOL previous_constructors = 0;
  474.   
  475. +   Module_t    module = (Module_t)theModule;    /* see above */
  476.     Symtab_t    symtab = module->symtab;
  477.     Class_t     object_class;
  478.     node_ptr node;
  479. ***************
  480. *** 273,287 ****
  481.        some data structures.  */
  482.     if (!previous_constructors) {
  483.   
  484.       /* Enable malloc debugging. This'll slow'er down! */
  485.   #if defined (DEBUG) && defined (NeXT)
  486.       malloc_debug (62);
  487.   #endif
  488.   
  489. -     /* Allocate and initialize the mutex.  */
  490. -     MUTEX_ALLOC (&runtimeMutex);
  491. -     MUTEX_INIT (runtimeMutex);
  492. - 
  493.       /* Allocate the module hash table.  */
  494.       module_hash_table
  495.         = hash_new (MODULE_HASH_SIZE, (hash_func_type)hash_ptr,
  496. --- 304,319 ----
  497.        some data structures.  */
  498.     if (!previous_constructors) {
  499.   
  500. +     __objc_msgSend = __initializing_objc_msgSend; 
  501. +     __objc_msgSendSuper = __initializing_objc_msgSendSuper; 
  502. +                 /* wee need a version checking for */
  503. +                 /* un-initialized classes here... */
  504. + 
  505.       /* Enable malloc debugging. This'll slow'er down! */
  506.   #if defined (DEBUG) && defined (NeXT)
  507.       malloc_debug (62);
  508.   #endif
  509.   
  510.       /* Allocate the module hash table.  */
  511.       module_hash_table
  512.         = hash_new (MODULE_HASH_SIZE, (hash_func_type)hash_ptr,
  513. ***************
  514. *** 348,354 ****
  515.         class1->class_pointer->class_pointer = object_class->class_pointer; 
  516.   
  517.         /* Assign super class pointers */
  518. !       if (class1->super_class) {
  519.       Class_t aSuperClass = objc_getClass ((char*)class1->super_class);
  520.   
  521.       if (aSuperClass) {
  522. --- 380,386 ----
  523.         class1->class_pointer->class_pointer = object_class->class_pointer; 
  524.   
  525.         /* Assign super class pointers */
  526. !       if ((((class1->info)&CLS_RTI)!=CLS_RTI) && class1->super_class) {
  527.       Class_t aSuperClass = objc_getClass ((char*)class1->super_class);
  528.   
  529.       if (aSuperClass) {
  530. ***************
  531. *** 362,375 ****
  532.   
  533.         /* Mark the class as initialized.  */
  534.         class1->info |= CLS_RTI;
  535. !     } else
  536.         /* Couldn't find the class's super class.  */
  537.         incomplete = 1;
  538.         }
  539.       }
  540. !   } else
  541.       /* Couldn't find class Object.  */
  542.       incomplete = 1;
  543.   
  544.     /* Process category information from the module.  */
  545.     for (i = 0; i < symtab->cat_def_cnt; ++i) {
  546. --- 394,413 ----
  547.   
  548.         /* Mark the class as initialized.  */
  549.         class1->info |= CLS_RTI;
  550. !     } else {
  551.         /* Couldn't find the class's super class.  */
  552.         incomplete = 1;
  553. +       DEBUG_PRINTF("Missing superclass for %s (%s)\n",
  554. +                class1->name, (char*)(class1->super_class));
  555. +     }
  556.         }
  557.       }
  558. !   } else {
  559.       /* Couldn't find class Object.  */
  560.       incomplete = 1;
  561. +     DEBUG_PRINTF("Missing class Object\n");
  562. +   }
  563. + 
  564.   
  565.     /* Process category information from the module.  */
  566.     for (i = 0; i < symtab->cat_def_cnt; ++i) {
  567. ***************
  568. *** 396,401 ****
  569. --- 434,440 ----
  570.        be found.  Save the information.  */
  571.         hash_add (&unclaimed_category_hash_table, category, category);
  572.   
  573. +       DEBUG_PRINTF("Missing class %s\n", category->class_name);
  574.         incomplete = 1;
  575.       }
  576.     }
  577. ***************
  578. *** 422,429 ****
  579.         if (category->class_methods)
  580.       addMethodsToClass ((Class_t)class->class_pointer,
  581.                  category->class_methods);
  582. !     } else
  583.         incomplete = 1;
  584.     }
  585.   
  586.     /* Can we finish the run time initialization? */
  587. --- 461,471 ----
  588.         if (category->class_methods)
  589.       addMethodsToClass ((Class_t)class->class_pointer,
  590.                  category->class_methods);
  591. !     } else {
  592. !       DEBUG_PRINTF("Missing class %s\n", category->class_name);
  593.         incomplete = 1;
  594. +     }
  595. + 
  596.     }
  597.   
  598.     /* Can we finish the run time initialization? */
  599. ***************
  600. *** 438,450 ****
  601.       /* Print out class tables if debugging.  */
  602.       DEBUG_PRINTF ("dump of class tables from objcInit\n");
  603.       debug_dump_classes ();
  604. !   }
  605.   
  606.   }
  607.   
  608.   
  609.   IMP  
  610. ! objc_msgSend (id receiver, SEL sel)
  611.   {
  612.     /*
  613.      * A method is always called by the compiler.  If a method wasn't
  614. --- 480,514 ----
  615.       /* Print out class tables if debugging.  */
  616.       DEBUG_PRINTF ("dump of class tables from objcInit\n");
  617.       debug_dump_classes ();
  618. ! 
  619. !     /* initialize all classes */
  620. !     for (node = hash_next (class_hash_table, NULL); node;
  621. !      node = hash_next (class_hash_table, node)) 
  622. !       if(!(((Class_t)node->value)->info & CLS_INITIALIZED)) 
  623. !     initialize_class(node->value);
  624. ! 
  625. !     __objc_msgSend = __builtin_objc_msgSend; 
  626. !     __objc_msgSendSuper = __builtin_objc_msgSendSuper; 
  627. !                 /* change to the fast versions */
  628.   
  629. +     /* Allocate and initialize the mutex.  */
  630. +     MUTEX_ALLOC (&runtimeMutex);
  631. +     MUTEX_INIT (runtimeMutex);
  632. + 
  633. +     MUTEX_ALLOC(&mallocMutex);
  634. +     MUTEX_INIT(mallocMutex);
  635. + 
  636. +   }
  637.   }
  638.   
  639.   
  640. + IMP objc_msgSend (id receiver, SEL sel) {
  641. +   return (*__objc_msgSend)(receiver,sel);
  642. + }
  643. + 
  644. + /* This is an cut-down messenger, which does only what is needed*/
  645.   IMP  
  646. ! __builtin_objc_msgSend (id receiver, SEL sel)
  647.   {
  648.     /*
  649.      * A method is always called by the compiler.  If a method wasn't
  650. ***************
  651. *** 452,466 ****
  652.      */
  653.     IMP  imp = nil_method;
  654.   
  655.   
  656.     /* The run time must be initialized at this point.
  657.        Otherwise we get a message sent to a object with a bogus selector.  */
  658. !   assert (initialized);
  659.   
  660.     /* Objective-C allows messages to be sent to a nil object.  */
  661.     if (receiver) {
  662.   
  663. !     /* Check for common programmer error.  */
  664.       if (!receiver->class_pointer) {
  665.         fprintf (stderr, "method %s sent to deallocated object %#x\n", 
  666.              sel_getName (sel), receiver);
  667. --- 516,569 ----
  668.      */
  669.     IMP  imp = nil_method;
  670.   
  671. +   /* Objective-C allows messages to be sent to a nil object.  */
  672. +   if (receiver) {
  673. +     /*
  674. +      * If we're passed a object then its class_pointer is a Class.  If
  675. +      * we're passed a Class then its class_pointer is a MetaClass. 
  676. +      * Therefore, searching for a instance or class method
  677. +      * requires no special decision making here. 
  678. +      *
  679. +      * Look for the method. 
  680. +      */
  681. +     imp = get_imp (receiver->class_pointer, sel);
  682. + 
  683. +     /* If the method cannot be found then perform error handling.  */
  684. +     if (!imp)
  685. +       imp = handle_runtime_error (receiver, sel);
  686. +   }
  687. + 
  688. + #ifdef DEBUG
  689. +   /* Nice debugging messages if enabled.  */
  690. +   if (objc_trace) {
  691. +     printf ("trace: objc_msgSend , obj=%#x, class=%s, method=%s\n",
  692. +         receiver, 
  693. +         receiver->class_pointer->name, 
  694. +         sel_getName (sel));
  695. +     fflush (stdout);
  696. +   }
  697. + #endif
  698. +   
  699. +   return imp;
  700. + }
  701. + 
  702. + IMP  
  703. + __initializing_objc_msgSend (id receiver, SEL sel)
  704. + {
  705. +   /*
  706. +    * A method is always called by the compiler.  If a method wasn't
  707. +    * found then supply a default. 
  708. +    */
  709. +   IMP  imp = nil_method;
  710.   
  711.     /* The run time must be initialized at this point.
  712.        Otherwise we get a message sent to a object with a bogus selector.  */
  713. !   assert(initialized);
  714.   
  715.     /* Objective-C allows messages to be sent to a nil object.  */
  716.     if (receiver) {
  717.   
  718. !     /* Check for common programmer error */
  719.       if (!receiver->class_pointer) {
  720.         fprintf (stderr, "method %s sent to deallocated object %#x\n", 
  721.              sel_getName (sel), receiver);
  722. ***************
  723. *** 469,475 ****
  724.       
  725.       /* Initialize the class if need be.  */
  726.       if (!(receiver->class_pointer->info & CLS_INITIALIZED))
  727. !       initialize_class (receiver->class_pointer->name);
  728.   
  729.       /*
  730.        * If we're passed a object then its class_pointer is a Class.  If
  731. --- 572,578 ----
  732.       
  733.       /* Initialize the class if need be.  */
  734.       if (!(receiver->class_pointer->info & CLS_INITIALIZED))
  735. !       initialize_class (receiver->class_pointer);
  736.   
  737.       /*
  738.        * If we're passed a object then its class_pointer is a Class.  If
  739. ***************
  740. *** 494,506 ****
  741.           sel_getName (sel));
  742.       fflush (stdout);
  743.     }
  744. !   
  745.     return imp;
  746.   }
  747.   
  748.   
  749.   IMP 
  750. ! objc_msgSendSuper (Super_t super, SEL sel)
  751.   {
  752.     IMP    imp;
  753.   
  754. --- 597,616 ----
  755.           sel_getName (sel));
  756.       fflush (stdout);
  757.     }
  758. ! 
  759.     return imp;
  760.   }
  761.   
  762.   
  763. + 
  764. + 
  765.   IMP 
  766. ! objc_msgSendSuper (Super_t super, SEL sel) {
  767. !   return (__objc_msgSendSuper)(super, sel);
  768. ! }
  769. ! 
  770. ! IMP 
  771. ! __initializing_objc_msgSendSuper (Super_t super, SEL sel)
  772.   {
  773.     IMP    imp;
  774.   
  775. ***************
  776. *** 508,516 ****
  777.     assert (initialized);
  778.   
  779.     if (!(super->class->info & CLS_INITIALIZED))
  780. !     initialize_class (super->class->name);
  781.     if (!(super->receiver->class_pointer->info & CLS_INITIALIZED))
  782. !     initialize_class (super->receiver->class_pointer->name);
  783.   
  784.     imp = get_imp (super->class, sel);
  785.     
  786. --- 618,626 ----
  787.     assert (initialized);
  788.   
  789.     if (!(super->class->info & CLS_INITIALIZED))
  790. !     initialize_class (super->class);
  791.     if (!(super->receiver->class_pointer->info & CLS_INITIALIZED))
  792. !     initialize_class (super->receiver->class_pointer);
  793.   
  794.     imp = get_imp (super->class, sel);
  795.     
  796. ***************
  797. *** 528,533 ****
  798. --- 638,653 ----
  799.     return imp;
  800.   }
  801.   
  802. + IMP 
  803. + __builtin_objc_msgSendSuper (Super_t super, SEL sel)
  804. + {
  805. +   IMP    imp;
  806. +   if(imp = get_imp (super->class, sel))
  807. +     return imp;
  808. +   else
  809. +     return handle_runtime_error (super->receiver, sel);
  810. + }
  811. + 
  812.   
  813.   /*
  814.    * This function is called by objc_msgSend or objc_msgSendSuper when a
  815. ***************
  816. *** 634,640 ****
  817.      *
  818.      * No need to initialize the class.  That was done in objcInit. 
  819.      */
  820. !   object = (id) xcalloc (1, class->instance_size);
  821.     object->class_pointer = class;
  822.   
  823.     return object;
  824. --- 754,760 ----
  825.      *
  826.      * No need to initialize the class.  That was done in objcInit. 
  827.      */
  828. !   object = (id) __objc_xcalloc (1, class->instance_size);
  829.     object->class_pointer = class;
  830.   
  831.     return object;
  832. ***************
  833. *** 661,667 ****
  834.     if (length < object->class_pointer->instance_size)
  835.       abort ();
  836.   
  837. !   obj = (id) realloc (object, length);
  838.     bzero ((char*)obj + object->class_pointer->instance_size,  
  839.        length - object->class_pointer->instance_size);
  840.     
  841. --- 781,787 ----
  842.     if (length < object->class_pointer->instance_size)
  843.       abort ();
  844.   
  845. !   obj = (id) __objc_xrealloc (object, length);
  846.     bzero ((char*)obj + object->class_pointer->instance_size,  
  847.        length - object->class_pointer->instance_size);
  848.     
  849. ***************
  850. *** 949,958 ****
  851.   Class_t 
  852.   class_poseAs (Class_t impostor, Class_t super_class)
  853.   {
  854. !   Class_t     new_class = (Class_t) calloc (1, sizeof (Class));
  855. !   MetaClass_t new_meta_class = (MetaClass_t) calloc (1, sizeof (MetaClass));
  856.     node_ptr node;
  857. !   char        *new_name = (char *) malloc (strlen (super_class->name) + 12);
  858.   
  859.     
  860.     assert (new_class);
  861. --- 1069,1078 ----
  862.   Class_t 
  863.   class_poseAs (Class_t impostor, Class_t super_class)
  864.   {
  865. !   Class_t     new_class = (Class_t) __objc_xcalloc (1, sizeof (Class));
  866. !   MetaClass_t new_meta_class = (MetaClass_t) __objc_xcalloc (1, sizeof (MetaClass));
  867.     node_ptr node;
  868. !   char        *new_name = (char *) __objc_xmalloc (strlen (super_class->name) + 12);
  869.   
  870.     
  871.     assert (new_class);
  872. ***************
  873. *** 1220,1235 ****
  874.    * is marked as initialized. 
  875.    */
  876.   static void        
  877. ! initialize_class (const char *name)
  878.   {
  879.     Method_t    method = NULL;
  880. -   Class_t    class = objc_getClass (name);
  881.     SEL        sel = sel_getUid ("initialize");
  882.   
  883.       
  884.     /* The class should not be initialized at this point.  */
  885.     assert (!(class->info & CLS_INITIALIZED));
  886. !   assert (!(class->class_pointer->info & CLS_INITIALIZED));
  887.   
  888.     /* Search for the +initialize method.
  889.        Call it if it exists.  */
  890. --- 1340,1358 ----
  891.    * is marked as initialized. 
  892.    */
  893.   static void        
  894. ! initialize_class (Class_t class)
  895.   {
  896.     Method_t    method = NULL;
  897.     SEL        sel = sel_getUid ("initialize");
  898.   
  899.       
  900.     /* The class should not be initialized at this point.  */
  901.     assert (!(class->info & CLS_INITIALIZED));
  902. !   /*assert (!(class->class_pointer->info & CLS_INITIALIZED));*/
  903. ! 
  904. !   /* Mark the class as initialized.  */
  905. !   class->info    |= CLS_INITIALIZED;
  906. !   class->class_pointer->info    |= CLS_INITIALIZED;
  907.   
  908.     /* Search for the +initialize method.
  909.        Call it if it exists.  */
  910. ***************
  911. *** 1240,1254 ****
  912.       IMP    imp;
  913.   
  914.       DEBUG_PRINTF ("Class: %s sending +%s\n", 
  915. !           name, sel_getName (sel));
  916.       imp = get_imp ((Class_t)class->class_pointer, sel);
  917.       assert (imp);
  918.       (*imp)((id)class, sel);
  919.     }
  920.   
  921. -   /* Mark the class as initialized.  */
  922. -   class->info    |= CLS_INITIALIZED;
  923. -   class->class_pointer->info    |= CLS_INITIALIZED;
  924.   }
  925.   
  926.   
  927. --- 1363,1374 ----
  928.       IMP    imp;
  929.   
  930.       DEBUG_PRINTF ("Class: %s sending +%s\n", 
  931. !           class->name, sel_getName (sel));
  932.       imp = get_imp ((Class_t)class->class_pointer, sel);
  933.       assert (imp);
  934.       (*imp)((id)class, sel);
  935.     }
  936.   
  937.   }
  938.   
  939.   
  940. diff -c ../orig/hash.c objc/hash.c
  941. *** ../orig/hash.c    Tue Feb  9 20:20:19 1993
  942. --- objc/hash.c    Tue Feb  9 04:07:26 1993
  943. ***************
  944. *** 23,31 ****
  945.      This exception does not however invalidate any other reasons why
  946.      the executable file might be covered by the GNU General Public License.  */
  947.   
  948. ! #include "tconfig.h"
  949. ! #include "gstddef.h"
  950. ! #include "gstdarg.h"
  951.   #include "assert.h"
  952.   
  953.   #include "hash.h"
  954. --- 23,30 ----
  955.      This exception does not however invalidate any other reasons why
  956.      the executable file might be covered by the GNU General Public License.  */
  957.   
  958. ! #include "stddef.h"
  959. ! #include "stdarg.h"
  960.   #include "assert.h"
  961.   
  962.   #include "hash.h"
  963. ***************
  964. *** 53,67 ****
  965.     assert (size);
  966.     assert (!(size & (size - 1)));
  967.   
  968. !   /* Allocate the cache structure.  calloc insures
  969.        its initialization for default values.  */
  970. !   cache = (cache_ptr) calloc (1, sizeof (struct cache));
  971.     assert (cache);
  972.   
  973.     /* Allocate the array of buckets for the cache.
  974. !      calloc initializes all of the pointers to NULL.  */
  975.     cache->node_table
  976. !     = (node_ptr *) calloc (size, sizeof (node_ptr));
  977.     assert (cache->node_table);
  978.   
  979.     cache->size  = size;
  980. --- 52,66 ----
  981.     assert (size);
  982.     assert (!(size & (size - 1)));
  983.   
  984. !   /* Allocate the cache structure.  xcalloc insures
  985.        its initialization for default values.  */
  986. !   cache = (cache_ptr) xcalloc (1, sizeof (struct cache));
  987.     assert (cache);
  988.   
  989.     /* Allocate the array of buckets for the cache.
  990. !      xcalloc initializes all of the pointers to NULL.  */
  991.     cache->node_table
  992. !     = (node_ptr *) xcalloc (size, sizeof (node_ptr));
  993.     assert (cache->node_table);
  994.   
  995.     cache->size  = size;
  996. ***************
  997. *** 100,106 ****
  998.   hash_add (cache_ptr *cachep, const void *key, void *value)
  999.   {
  1000.     size_t indx = (*(*cachep)->hash_func)(*cachep, key);
  1001. !   node_ptr node = (node_ptr) calloc (1, sizeof (struct cache_node));
  1002.   
  1003.   
  1004.     assert (node);
  1005. --- 99,105 ----
  1006.   hash_add (cache_ptr *cachep, const void *key, void *value)
  1007.   {
  1008.     size_t indx = (*(*cachep)->hash_func)(*cachep, key);
  1009. !   node_ptr node = (node_ptr) xcalloc (1, sizeof (struct cache_node));
  1010.   
  1011.   
  1012.     assert (node);
  1013. ***************
  1014. *** 252,254 ****
  1015. --- 251,256 ----
  1016.   
  1017.     return retval;
  1018.   }
  1019. + 
  1020. + 
  1021. + 
  1022. diff -c ../orig/object.m objc/object.m
  1023. *** ../orig/object.m    Tue Feb  9 20:20:21 1993
  1024. --- objc/object.m    Tue Feb  9 03:45:48 1993
  1025. ***************
  1026. *** 1,3 ****
  1027. --- 1,15 ----
  1028. + /* This may look like -*- C -*- but it is really objective C */
  1029. + 
  1030. + /* $Log: Object.m,v $
  1031. +  * Revision 1.3  1993/02/08  20:05:15  krab
  1032. +  * Changed hash and isEqual to examine instance variables
  1033. +  *
  1034. +  * 6-Feb-1993        Kresten Krab Thorup    
  1035. +  *    Changed deepCopy
  1036. +  * 6-Feb-1993        Kresten Krab Thorup    
  1037. +  *    Changed to alloc/init scheme.  
  1038. +  */
  1039. + 
  1040.   /* This file contains the implementation of class Object.
  1041.      Copyright (C) 1992 Free Software Foundation, Inc.
  1042.   
  1043. ***************
  1044. *** 18,26 ****
  1045.   the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  1046.    
  1047.   
  1048. ! #include "tconfig.h"
  1049. ! #include "gstdarg.h"
  1050. ! #include "object.h"
  1051.   #include "objc-proto.h"
  1052.   
  1053.   #include <errno.h>
  1054. --- 30,37 ----
  1055.   the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  1056.    
  1057.   
  1058. ! #include "stdarg.h"
  1059. ! #include "Object.h"
  1060.   #include "objc-proto.h"
  1061.   
  1062.   #include <errno.h>
  1063. ***************
  1064. *** 34,61 ****
  1065.   @implementation Object
  1066.   
  1067.   
  1068. ! + new
  1069. ! {
  1070. !   return class_createInstance (CLASS (self));
  1071. ! }
  1072. ! 
  1073.   
  1074.   + free {  return nil; }
  1075.   - free {  return object_dispose (self); }
  1076.   
  1077. - 
  1078.   - copy {  return [self shallowCopy]; }
  1079.   
  1080. - 
  1081.   - shallowCopy
  1082.   {
  1083.     return object_copy (self);
  1084.   }
  1085.   
  1086. - 
  1087.   - deepCopy
  1088.   {
  1089. !   return class_createInstance ([self class]);
  1090.   }
  1091.   
  1092.   
  1093. --- 45,67 ----
  1094.   @implementation Object
  1095.   
  1096.   
  1097. ! + alloc {  return class_createInstance (CLASS (self)); }
  1098. ! + new   {  return [[self alloc] init]; }
  1099. ! - init  {  return self; }
  1100.   
  1101.   + free {  return nil; }
  1102.   - free {  return object_dispose (self); }
  1103.   
  1104.   - copy {  return [self shallowCopy]; }
  1105.   
  1106.   - shallowCopy
  1107.   {
  1108.     return object_copy (self);
  1109.   }
  1110.   
  1111.   - deepCopy
  1112.   {
  1113. !   return object_copy (self);
  1114.   }
  1115.   
  1116.   
  1117. ***************
  1118. *** 69,83 ****
  1119.   
  1120.   - (unsigned int)hash
  1121.   {
  1122. !   return (unsigned int)self; /* gak!  Not portable. */
  1123.   }
  1124.   
  1125. - 
  1126.   - (BOOL)isEqual:anObject
  1127.   {
  1128. !   return self == anObject ;
  1129.   }
  1130.   
  1131.   
  1132.   - (BOOL)isKindOf:(Class_t)aClassObject
  1133.   {
  1134. --- 75,104 ----
  1135.   
  1136.   - (unsigned int)hash
  1137.   {
  1138. !   if(isa->instance_size > sizeof(Object))
  1139. !     {
  1140. !       register unsigned cnt, res;
  1141. !       for(cnt=0, res=0; cnt < isa->instance_size; cnt++)
  1142. !     res += ((char*)self)[cnt];
  1143. !       return res;
  1144. !     }
  1145. !   else    /* no instance variables -- use adress */
  1146. !     return ((unsigned int)self)>>3;
  1147.   }
  1148.   
  1149.   - (BOOL)isEqual:anObject
  1150.   {
  1151. !   if(self->isa != anObject->isa) 
  1152. !     return NO;
  1153. !   if(isa->instance_size != anObject->isa->instance_size)
  1154. !     return NO;
  1155. !   return bcmp(self, anObject, isa->instance_size) == 0 ? YES : NO;
  1156.   }
  1157.   
  1158. + + (BOOL)isEqual: aClass
  1159. + {
  1160. +   return self==aClass ? YES : NO;
  1161. + }
  1162.   
  1163.   - (BOOL)isKindOf:(Class_t)aClassObject
  1164.   {
  1165. ***************
  1166. *** 145,150 ****
  1167. --- 166,177 ----
  1168.   }
  1169.   
  1170.   
  1171. + - perform:(SEL)aSel with:aObject with:secondObject
  1172. + {
  1173. +   return (*((IMP)objc_msgSend (self, aSel)))(self, aSel, aObject,secondObject);
  1174. + }
  1175. + 
  1176. + 
  1177.   + poseAs:(Class_t)aClassObject
  1178.   {
  1179.     return class_poseAs (self, aClassObject);
  1180. ***************
  1181. *** 153,171 ****
  1182.    
  1183.   - subclassResponsibility:(SEL)aSel
  1184.   {
  1185. !   return [self error:"subclass should override %s", aSel];
  1186.   }
  1187.   
  1188.   
  1189.   - notImplemented:(SEL)aSel
  1190.   {
  1191. !   return [self error:"method %s not implemented", aSel];
  1192.   }
  1193.   
  1194.   
  1195.   - doesNotRecognize:(SEL)aSel
  1196.   {
  1197. !   return [self error:"%s does not recognize %s", [self name], aSel];
  1198.   }
  1199.   
  1200.   - error:(const char*)aString, ...
  1201. --- 180,198 ----
  1202.    
  1203.   - subclassResponsibility:(SEL)aSel
  1204.   {
  1205. !   return [self error:"subclass should override %s", sel_getName(aSel)];
  1206.   }
  1207.   
  1208.   
  1209.   - notImplemented:(SEL)aSel
  1210.   {
  1211. !   return [self error:"method %s not implemented", sel_getName(aSel)];
  1212.   }
  1213.   
  1214.   
  1215.   - doesNotRecognize:(SEL)aSel
  1216.   {
  1217. !   return [self error:"%s does not recognize %s", [self name], sel_getName(aSel)];
  1218.   }
  1219.   
  1220.   - error:(const char*)aString, ...
  1221. ***************
  1222. *** 221,226 ****
  1223. --- 248,256 ----
  1224.     return self;
  1225.   }
  1226.   
  1227. +  /* This method reads the header "#<class-name>\0<version>". Finds the */
  1228. +  /* class, and checks it version.  Finally it creates a new instance */
  1229. +  /* of that class, and sends it the message -readFrom: */
  1230.   
  1231.   + readFrom:(int)aFd
  1232.   {
  1233. ***************
  1234. *** 228,234 ****
  1235.     char  objName[256];
  1236.     int   len;
  1237.     
  1238. -   
  1239.     if ((len = read (aFd, &objName, strlen ("#"))) != -1)
  1240.       if (objName[0] == '#') {
  1241.         long  version;
  1242. --- 258,263 ----
  1243. ***************
  1244. *** 243,264 ****
  1245.         if (len != -1)
  1246.           len = read (aFd, &version, sizeof (version));
  1247.         
  1248. !       /* No errors???
  1249. !      Then create a object. */
  1250.         if (len != -1) {
  1251. !     aObj = class_createInstance (objc_getClass (objName));
  1252. !           
  1253. !     /* If the object was 
  1254. !        successfully created then
  1255. !        tell it to dearchive
  1256. !        itself. */
  1257. !     if (aObj)
  1258.         [aObj readFrom:aFd];
  1259.         }
  1260.       }
  1261.       
  1262.     if (len == -1)
  1263. !     [self error:"error activating object, errno=%d", errno];
  1264.     
  1265.     return aObj;
  1266.   }
  1267. --- 272,294 ----
  1268.         if (len != -1)
  1269.           len = read (aFd, &version, sizeof (version));
  1270.         
  1271. !       /* No errors??? Then create a object. */
  1272.         if (len != -1) {
  1273. !     Class_t aClass = objc_getClass(objName);
  1274. !     if(aClass == nil)
  1275. !       [self error: "readFrom: Cannot find class %s", objName];
  1276. !     else if ([aClass version] != version)
  1277. !       [self error: "readFrom: Bad version: %d of class %s", version, objName];
  1278. ! 
  1279. !     if(aObj = class_createInstance (aClass))
  1280.         [aObj readFrom:aFd];
  1281. +     else
  1282. +       [self error: "readFrom: Cannot create instance of class %s", aClass];
  1283.         }
  1284.       }
  1285.       
  1286.     if (len == -1)
  1287. !     [self error:"readFrom: I/O error activating object, errno=%d", errno];
  1288.     
  1289.     return aObj;
  1290.   }
  1291.  
  1292. Return-Path: <bradcox@sitevax.gmu.edu>
  1293. Date: Wed, 10 Feb 1993 11:51:12 -0500
  1294. To: Kresten Krab Thorup <krab@iesd.auc.dk>, gnu-objc-runtime@prep.ai.mit.edu
  1295. From: bradcox@sitevax.gmu.edu (Brad Cox; 703 968 8229)
  1296. Subject: Re: Gnu objc runtime [comments and bug reports]
  1297. Cc: "Geoffrey S. Knauth" <gsk@marble.com>, rms@gnu.ai.mit.edu,
  1298.         gnu-objc-submissions@prep.ai.mit.edu
  1299.  
  1300. krab@iesd.auc.dk wrote:
  1301. >     # Changed isEqual so that bcmp on instances is done, instead of
  1302. >     comparing the object pointers only.  I dont know if this is the
  1303. >     right semathics, but it surely is more natural.  
  1304.  
  1305. There is no single *right* semantics for isEqual: at the generic Object
  1306. level. You're confusing the difference between fixing a bug and redefining
  1307. a standard.
  1308.  
  1309. I encourage you to undo this fix by adopting (1) the simplest to explain
  1310. (2) the smallest to implement and (3) the one discussed in my book and (4)
  1311. the one adopted in existing Object class implementations; namely that
  1312. unless overridden, equality == identity; i.e.
  1313.  
  1314. - isEqual: anObject { return anObject == self; }
  1315.  
  1316. Don't forget that unfixing isEqual: will also require unfixing hash.
  1317. --
  1318.    Brad Cox; bradcox@sitevax.gmu.edu; 703 993 1142 work 703 968 8229 home 
  1319.  George Mason Program on Social and Organizational Learning; Fairfax VA 22030
  1320.  
  1321.  
  1322. Return-Path: <dglattin@trirex.com>
  1323. Date: Wed, 10 Feb 93 20:57:58 -0800
  1324. From: Dennis Glatting <dglattin@trirex.com>
  1325. To: "Geoffrey S. Knauth" <gsk@marble.com>
  1326. Subject: Re: [krab@iesd.auc.dk: Gnu objc runtime [comments and bug reports]]
  1327. Cc: gnu-objc-runtime@prep.ai.mit.edu
  1328. Reply-To: dennis_glatting@trirex.com
  1329.  
  1330. > # Changed msgSend scheme:  objc_msgSend is now a pointer
  1331. > two a function. core.c defines two messengers, one equal
  1332. > to the present doing extensively initialization
  1333. > checking, and one bare-bone with no such checks (more on
  1334. > initialization at next item) This also allows the
  1335. > programmer to do his own messengers -- fun! 
  1336.  
  1337. > 
  1338.  
  1339.  
  1340. Trade off.  Adds overhead to *every* message dispatch.
  1341.  
  1342.  
  1343. > When all classes have their class-relationships
  1344. > resolved, (i.e. the last time it is called), It calls
  1345. > +initialize for all classes.  (still using the heavy
  1346. > messenger)  it is not called if it has already been done if a
  1347. > +initialize method has invoked it indirectly by doing
  1348. > message passing to other objects. 
  1349.  
  1350. > 
  1351.  
  1352.  
  1353. This is contrary to the definition of the +initialize.  Also, I did  
  1354. this once.  There are problems.  For example, what if a +initialize  
  1355. method allocates a object of another class?  The +initialize method  
  1356. of the second class hasn't been called yet.  How is the +initialize  
  1357. method of the second class called?  By checking to see if the class  
  1358. has been initialized.  So what's the point of executing all  
  1359. +initialize methods at once?
  1360.  
  1361.  
  1362. -dpg
  1363.  
  1364. Return-Path: <krab@iesd.auc.dk>
  1365. Date: Wed, 24 Feb 1993 09:52:42 +0100
  1366. From: Kresten Krab Thorup <krab@iesd.auc.dk>
  1367. To: Bill Dudney <dudney@pencom.com>
  1368. In-Reply-To: <9302232343.AA02036@>
  1369. Subject: Help with the runtime
  1370. Cc: krab@iesd.auc.dk, rms@gnu.ai.mit.edu, burchard@geom.umn.edu,
  1371.         gsk@marble.com
  1372.  
  1373. Bill Dudney writes:
  1374. >Is there some way I can help? I dont have a very good feel for the
  1375. >state of the run time system now but I do know NeXTs run time pretty
  1376. >well and would be happy to help get GNU's up to snuff.
  1377.  
  1378. Since I don't think the current runtime is worth anything I have
  1379. started writing the runtime from scratch.  As the runtime is only a
  1380. 2-3 thousand lines of C code, I think it would be best if I did it
  1381. alone until I have something which is close to a full runtime.  But
  1382. there are a few points where I really need help.
  1383.  
  1384. (1) Since we do not have a specification of the objective C language
  1385. it is my worst worry if I do it absolutely correct.  There are several
  1386. things which could be done:
  1387.  
  1388.    1) Writing a specification of the objective C language. 
  1389.  
  1390.    2) Writing a specification of the programmer/runtime interface.
  1391.  
  1392. Currently I use the NeXT documentation, and the existing C code to
  1393. make these matters certain.  For example, the exact semathics of
  1394. posing is still a bit unclear to me...  Should the class being posed
  1395. for be accessible in any way after the poseAs call?
  1396.  
  1397.  
  1398. (2) The type encoding format needs revision/redesign.  Stallman, Paul
  1399. and I have had some discussions on this, and if you're interested in
  1400. writing a some documentation, you're welcome.  One problem not exactly
  1401. solved yet, is how to manage translations to and from machine
  1402. independent format, and who's resplonsibility it should be to do so --
  1403. the runtime? the compiler? the code in typedstreams?.  We also need
  1404. someone to actually code things like typed streams.  This is not
  1405. critical for the core runtime, and could be done later.
  1406.  
  1407.  
  1408. (3) Whenever I or other people introduce ideas for new features or how
  1409. to implement them, take your time to evaluate them carefully, and
  1410. ** answer to the gnu-objc list ** , so that we can discuss it in a wide
  1411. forum.  This is the intermediate way to handle (1).
  1412.  
  1413.  
  1414. (4) Once I get something up running, be a *critical* beta-tester.
  1415. This -- I guess -- will take a week or two before I have anything
  1416. presentable to testers.
  1417.  
  1418.  
  1419. Geoffrey:  If you think it would be a good idea, you're welcome to
  1420. post this note to the list.  Perhaps someone has more problems to add? 
  1421.  
  1422. Thanks,
  1423.  
  1424. Kresten
  1425.  
  1426.  
  1427.